\chapter{序列}

\section{列表}

\subsection{列表（List）}

列表用于存储多个数据，使用[]或list()函数创建。列表中的元素可以通过下标来访问，下标从0开始。列表除了正向索引访问之外，也可以进行反向索引访问。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
lst = [1, 2, 3]

print(lst[0])		# 1
print(lst[1])		# 2
print(lst[2])		# 3

print(lst[-1])		# 3
print(lst[-2])		# 2
print(lst[-3])		# 1

print(lst[3])       # IndexError
\end{lstlisting}

+运算符可以用于列表的拼接，*运算符可以用于列表的重复。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
lst = [1, 2, 3] + [4, 5, 6]
print(lst)      # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3] * 3
print(lst)      # [1, 2, 3, 1, 2, 3, 1, 2, 3]
\end{lstlisting}

\vspace{0.5cm}

\subsection{in}

in运算符用于判断某个元素是否在序列中，如果在则返回True，否则返回False。\\

\mybox{查询}

\begin{lstlisting}[language=Python]
languages = ["C", "C++", "Python", "Java"]
key = input("Enter a language: ")

if key in languages:
	print("Found")
else:
	print("Not found")
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
Enter a language: Python
Found
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\subsection{切片（Slicing）}

切片用于截取列表中的一部分元素，切片使用[start:end:step]进行操作，其中：

\begin{itemize}
	\item start：切片开始下标（包含），默认为0
	\item end：切片结束下标（不包含），默认为列表长度
	\item step：切片的步长，默认为1
\end{itemize}

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
lst = list(range(10))

print(lst)			# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[2:7])		# [2, 3, 4, 5, 6]
print(lst[:5])		# [0, 1, 2, 3, 4]
print(lst[3:])		# [3, 4, 5, 6, 7, 8, 9]
print(lst[:])		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[::2])		# [0, 2, 4, 6, 8]
\end{lstlisting}

\vspace{0.5cm}

\subsection{列表方法}

列表提供了很多内置方法，可以用于处理列表中的数据。\\

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|l|l|}
			\hline
			\textbf{方法} & \textbf{功能}                  \\
			\hline
			append()      & 追加数据                       \\
			\hline
			extend()      & 追加列表                       \\
			\hline
			insert()      & 指定位置插入                   \\
			\hline
			remove()      & 删除第一个出现的指定数据       \\
			\hline
			pop()         & 删除指定位置的数据             \\
			\hline
			index()       & 查询指定数据第一次出现的位置   \\
			\hline
			count()       & 统计指定数据在列表中出现的次数 \\
			\hline
			sort()        & 对列表进行排序                 \\
			\hline
			reverse()     & 对列表进行反转                 \\
			\hline
			clear()       & 清空列表                       \\
			\hline
		\end{tabular}
	}
	\caption{列表方法}
\end{table}

\vspace{0.5cm}

\mybox{列表方法}

\begin{lstlisting}[language=Python]
lst = list(range(5))
print("lst =", lst)

lst.append(5)
print("append(5):", lst)

lst.insert(0, 8)
print("insert(0, 8):", lst)

lst.extend([8, 2, 3])
print("extend([8, 2, 3]):", lst)

lst.remove(5)
print("remove(5):", lst)

lst.pop(0)
print("pop(0):", lst)

print("index(3):", lst.index(3))

print("count(8):", lst.count(8))

lst.sort()
print("sort():", lst)

lst.sort(reverse=True)
print("sort(reverse=True):", lst)

lst.reverse()
print("reverse():", lst)

lst.clear()
print("clear():", lst)
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
lst = [0, 1, 2, 3, 4]
append(5): [0, 1, 2, 3, 4, 5]
insert(0, 8): [8, 0, 1, 2, 3, 4, 5]
extend([8, 2, 3]): [8, 0, 1, 2, 3, 4, 5, 8, 2, 3]
remove(5): [8, 0, 1, 2, 3, 4, 8, 2, 3]
pop(0): [0, 1, 2, 3, 4, 8, 2, 3]
index(3): 3
count(8): 1
sort(): [0, 1, 2, 2, 3, 3, 4, 8]
sort(reverse=True): [8, 4, 3, 3, 2, 2, 1, 0]
reverse(): [8, 4, 3, 3, 2, 2, 1, 0]
clear(): []
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\subsection{二维列表}

二维列表由行和列两个维度组成，行和列的下标同样也都是从0开始。二维列表可以看成是由多个列表组成的，因此二维列表中的每个元素都是一个列表。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
lst = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
\end{lstlisting}

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|c|c|c|c|}
			\hline
			lst[0][0] & lst[0][1] & lst[0][2] & lst[0][3] \\
			\hline
			lst[1][0] & lst[1][1] & lst[1][2] & lst[1][3] \\
			\hline
			lst[2][0] & lst[2][1] & lst[2][2] & lst[2][3] \\
			\hline
		\end{tabular}
	}
\end{table}

在初始化二维列表时，为了能够更直观地看出二维列表的结构，可以将每一行单独写在一行中。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
lst = [
	[1, 2, 3, 4],
	[5, 6, 7, 8],
	[9, 10, 11, 12],
]
\end{lstlisting}

\vspace{0.5cm}

\mybox{矩阵运算}

\begin{align}\nonumber
	\left[\begin{matrix}
			1 & 3 \\
			1 & 0 \\
			1 & 2 \\
		\end{matrix} \right]
	+
	\left[\begin{matrix}
			0 & 0 \\
			7 & 5 \\
			2 & 1 \\
		\end{matrix} \right]
	=
	\left[\begin{matrix}
			1+0 & 3+0 \\
			1+7 & 0+5 \\
			1+2 & 2+1 \\
		\end{matrix} \right]
	=
	\left[\begin{matrix}
			1 & 3 \\
			8 & 5 \\
			3 & 3 \\
		\end{matrix} \right]
\end{align}

\begin{align}\nonumber
	\left[\begin{matrix}
			1 & 3 \\
			1 & 0 \\
			1 & 2 \\
		\end{matrix} \right]
	-
	\left[\begin{matrix}
			0 & 0 \\
			7 & 5 \\
			2 & 1 \\
		\end{matrix} \right]
	=
	\left[\begin{matrix}
			1-0 & 3-0 \\
			1-7 & 0-5 \\
			1-2 & 2-1 \\
		\end{matrix} \right]
	=
	\left[\begin{matrix}
			1  & 3  \\
			-6 & -5 \\
			-1 & 1  \\
		\end{matrix} \right]
\end{align}

\begin{lstlisting}[language=Python]
A = [
	[1, 3],
	[1, 0],
	[1, 2]
]

B = [
	[0, 0],
	[7, 5],
	[2, 1]
]

C = []
print("Matrix Addition")
for i in range(3):
	C.append([])
	for j in range(2):
		C[i].append(A[i][j] + B[i][j])
		print("%3d" % C[i][j], end='')
	print()

C = []
print("Matrix Subtraction")
for i in range(3):
	C.append([])
	for j in range(2):
		C[i].append(A[i][j] - B[i][j])
		print("%3d" % C[i][j], end='')
	print()
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
Matrix Addition
  1  3
  8  5
  3  3
Matrix Subtraction
  1  3
  -6 -5
  -1  1
	\end{verbatim}
\end{tcolorbox}

\newpage

\section{元组}

\subsection{元组（Tuple）}

元组与列表类似，但是元组中的元素是不可修改的。元素使用()或tuple()定义，当元组只有一个元素时，必须在元素后面加上逗号。\\

\mybox{两点间距离}

\begin{lstlisting}[language=Python]
import math

p1 = (0, 0)
p2 = (3, 4)
distance = math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
print(distance)
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
5.0
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\subsection{序列统计函数}

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|l|l|}
			\hline
			\textbf{函数} & \textbf{功能}                              \\
			\hline
			len()         & 获取序列的长度                             \\
			\hline
			max()         & 获取序列中的最大值                         \\
			\hline
			min()         & 获取序列中的最小值                         \\
			\hline
			sum()         & 计算序列中的内容总和                       \\
			\hline
			any()         & 序列中有一个为True结果为True，否则为False  \\
			\hline
			all()         & 序列中有一个为False结果为False，否则为True \\
			\hline
		\end{tabular}
	}
	\caption{序列统计函数}
\end{table}

\begin{lstlisting}[language=Python]
lst = [4, 0, 1, 3, 2]
tup = (8, 5, 7, 9)

print(len(lst))		# 5
print(len(tup))		# 4

print(max(lst))		# 4
print(max(tup))		# 9

print(min(lst))		# 0
print(min(tup))		# 5

print(sum(lst))		# 10
print(sum(tup))		# 29
\end{lstlisting}

\newpage

\section{集合}

\subsection{集合（Set）}

集合表示一组无序且不重复的元素，使用\{\}或set()定义。\\

集合是无序的，因此不能通过下标来访问集合中的元素，但是可以通过in来判断元素是否在集合中。\\

集合支持数学上的集合运算，包括交集、并集、差集等：

\begin{itemize}
	\item 交集：intersection()或\&
	\item 并集：union()或|
	\item 差集：difference()或-
\end{itemize}

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
s1 = {1, 2, 3}
s2 = {3, 4, 5}

print(s1 & s2)				# {3}
print(s1.intersection(s2))	# {3}

print(s1 | s2)				# {1, 2, 3, 4, 5}
print(s1.union(s2))			# {1, 2, 3, 4, 5}

print(s1 - s2)				# {1, 2}
print(s1.difference(s2))	# {1, 2}
\end{lstlisting}

\vspace{0.5cm}

\mybox{列表去重}

\begin{lstlisting}[language=Python]
lst = [1, 9, 2, 0, 0, 9]
lst = list(set(lst))
print(lst)
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
[0, 1, 2, 9]
	\end{verbatim}
\end{tcolorbox}

\newpage

\section{字符串}

\subsection{字符串修改}

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|l|l|}
			\hline
			\textbf{方法} & \textbf{功能}    \\
			\hline
			lower()       & 转换小写         \\
			\hline
			upper()       & 转换大写         \\
			\hline
			capitalize()  & 首字母大写       \\
			\hline
			strip()       & 去除首尾空白字符 \\
			\hline
			replace()     & 字符串替换       \\
			\hline
		\end{tabular}
	}
\end{table}

\mybox{字符串修改}

\begin{lstlisting}[language=Python]
s = "Hello World!"

print("[Lower]")
print(s.lower())

print("[Upper]")
print(s.upper())

print("[Capitalize]")
print(s.capitalize())

print("[Strip]")
print("   Hello World!\n \t".strip())

print("[Replace]")
print(s.replace("Hello", "Bye"))
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
[Lower]
hello world!
[Upper]
HELLO WORLD!
[Capitalize]
Hello world!
[Strip]
Hello World!
[Replace]
Bye World!
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\subsection{字符串分割}

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|l|l|}
			\hline
			\textbf{方法} & \textbf{功能} \\
			\hline
			join()        & 字符串拼接    \\
			\hline
			split()       & 字符串分割    \\
			\hline
		\end{tabular}
	}
\end{table}

\mybox{日期}

\begin{lstlisting}[language=Python]
date_time = "2023/1/14 23:26:51"

date, time = date_time.split(" ")

year, month, day = date.split("/")
hour, minute, second = time.split(":")

date = [day, month, year]
date = "/".join(date)

if int(hour) < 12:
	time = [hour, minute, second]
	time = ":".join(time) + " AM"
else:
	time = [str(int(hour) - 12), minute, second]
	time = ":".join(time) + " PM"

date_time = date + " " + time
print(date_time)
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
14/1/2023 11:26:51 PM
\end{verbatim}
\end{tcolorbox}

\newpage

\section{字典}

\subsection{字典（Dictionary）}

字典中的每个元素都是一组键值对（key-value pair），其中key是唯一的，value可以重复。字典是一种无序的结构，通过\{\}或dict()定义，通过key来访问value。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
info = {"name": "Terry", "age": 24, "height": 179.2}
info = dict(name="Terry", age=24, height=179.2)
\end{lstlisting}

在使用for循环迭代字典时，迭代的是字典中的key，并不是一个键值对。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
for key in info:
	print("key=%s, value=%s" % (key, info[key]))
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
key=name, value=Terry
key=age, value=24
key=height, value=179.2
\end{verbatim}
\end{tcolorbox}

通过items()方法可以返回一个包含所有键值对的列表，列表中的每个元素都是一个键值对。这样再使用for循环迭代字典时，就可以同时迭代key和value。

\vspace{-0.5cm}

\begin{lstlisting}[language=Python]
for key, value in info.items():
	print("key=%s, value=%s" % (key, value))
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
key=name, value=Terry
key=age, value=24
key=height, value=179.2
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\subsection{字典方法}

\begin{table}[H]
	\centering
	\setlength{\tabcolsep}{5mm}{
		\begin{tabular}{|l|l|}
			\hline
			\textbf{方法} & \textbf{功能}         \\
			\hline
			keys()        & 获取字典中全部的key   \\
			\hline
			values()      & 获取字典中全部的value \\
			\hline
			update()      & 更新字典数据          \\
			\hline
			get()         & 根据key获取value      \\
			\hline
			pop()         & 根据key删除键值对     \\
			\hline
			popitem()     & 随机删除一个键值对    \\
			\hline
			clear()       & 清空字典              \\
			\hline
		\end{tabular}
	}
	\caption{字典方法}
\end{table}

\mybox{字典方法}

\begin{lstlisting}[language=Python]
info = {"name": "Terry"}
print("info =", info)

info.update({"age": 24, "height": 179.2})
print("update() =", info)

print("keys() =", info.keys())
print("values() =", info.values())

print("get('age') = ", info.get("age"))

info.pop("height")
print("pop('height') =", info)

info.popitem()
print("popitem() =", info)

info.clear()
print("clear() =", info)
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
info = {'name': 'Terry'}
update() = {'name': 'Terry', 'age': 24, 'height': 179.2}
keys() = dict_keys(['name', 'age', 'height'])
values() = dict_values(['Terry', 24, 179.2])
get('age') =  24
pop('height') = {'name': 'Terry', 'age': 24}
popitem() = {'name': 'Terry'}
clear() = {}
\end{verbatim}
\end{tcolorbox}

\vspace{0.5cm}

\mybox{词频统计}

\begin{lstlisting}[language=Python]
import string

text = """John sat on the park bench,
eating his sandwich and enjoying the warm sun on his face.
He watched the children playing and the ducks swimming in the pond,
feeling content and at peace.
"""

words = text.split()
frequency = {}

for word in words:
	word = word.lower().strip(string.punctuation)

	if word not in frequency:
		frequency[word] = 1
	else:
		frequency[word] += 1

for word, count in frequency.items():
	print("%s: %d" % (word, count))
\end{lstlisting}

\begin{tcolorbox}
	\mybox{运行结果}
	\begin{verbatim}
john: 1
sat: 1
on: 2
the: 5
park: 1
bench: 1
eating: 1
his: 2
sandwich: 1
and: 3
enjoying: 1
warm: 1
sun: 1
face: 1
he: 1
watched: 1
children: 1
playing: 1
ducks: 1
swimming: 1
in: 1
pond: 1
feeling: 1
content: 1
at: 1
peace: 1
\end{verbatim}
\end{tcolorbox}

\newpage